home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / gcc / ixemlsrc.lha / ixemul / general / arith.c < prev    next >
C/C++ Source or Header  |  1996-03-13  |  13KB  |  775 lines
  1. #include "common.h"
  2. #include "defs.h"
  3. #include <proto/mathieeedoubbas.h>
  4. #include <proto/mathieeedoubtrans.h>
  5. #include <proto/mathieeesingbas.h>
  6.  
  7. /*  Special patch to work around bug in IEEEDPCmp:
  8.  *  if the first 32 bits of both doubles are equal, and
  9.  *  both doubles are negative, then the result can no longer
  10.  *  be trusted.
  11.  * 
  12.  *  This is the output of a small test program:
  13.  *
  14.  *    test -2.000001 -2.0000009
  15.  *    a = -2.0000009999999996956888, b = -2.0000008999999998593466
  16.  *    (0xc0000000 0x8637bd05, 0xc0000000 0x78cbc3b8)
  17.  *    cmp(a,b) = 0, cmp(b,a) = 1
  18.  *
  19.  *    test -2.0000001 -2.0000002
  20.  *    a = -2.00000009999999983634211, b = -2.0000001999999996726842
  21.  *    (0xc0000000 0xd6bf94d, 0xc0000000 0x1ad7f29a)
  22.  *    cmp(a,b) = 1, cmp(b,a) = 1
  23.  *
  24.  *  As you can see, the results are wrong.
  25.  *
  26.  *  So, we just make both variables positive and exchange them before
  27.  *  passing them to IEEEDPCmp.
  28.  *
  29.  *  This bug was discovered by Bart Van Assche, thanks!
  30.  */
  31.  
  32. static int ieeedpcmp(double a, double b)
  33. {
  34.   if (*((char *)&a) & *((char *)&b) & 0x80)  /* both doubles negative? */
  35.     {
  36.       *((char *)&a) &= 0x7f;    /* yes, make positive */
  37.       *((char *)&b) &= 0x7f;
  38.       return IEEEDPCmp(b, a);   /* pass them to IEEEDPCmp the other way round */
  39.     }
  40.   return IEEEDPCmp(a, b);
  41. }
  42.  
  43. #if defined(L__eqdf2) || defined(ALL)
  44. int __eqdf2 (double a, double b)
  45. {
  46.   return ieeedpcmp (a, b);
  47. }
  48. #endif
  49.  
  50. #if defined(L__eqsf2) || defined(ALL)
  51. int __eqsf2 (FLOAT a, FLOAT b)
  52. {
  53.   return IEEESPCmp (a, b);
  54. }
  55. #endif
  56.  
  57. #if defined(L__fixsfsi) || defined(ALL)
  58. SItype __fixsfsi (FLOAT a)
  59. {
  60.   return IEEESPFix(a);
  61. }
  62. #endif
  63.  
  64. #if defined(L__floatsisf) || defined(ALL)
  65. SFVALUE __floatsisf (SItype a)
  66. {
  67.   return IEEESPFlt(a);
  68. }
  69. #endif
  70.  
  71. #if defined(L__gedf2) || defined(ALL)
  72. int __gedf2 (double a, double b)
  73. {
  74.   return ieeedpcmp (a, b);
  75. }
  76. #endif
  77.  
  78. #if defined(L__gesf2) || defined(ALL)
  79. int __gesf2 (FLOAT a, FLOAT b)
  80. {
  81.   return IEEESPCmp (a, b);
  82. }
  83. #endif
  84.  
  85. #if defined(L__gtdf2) || defined(ALL)
  86. int __gtdf2 (double a, double b)
  87. {
  88.   return ieeedpcmp (a, b);
  89. }
  90. #endif
  91.  
  92. #if defined(L__gtsf2) || defined(ALL)
  93. int __gtsf2 (FLOAT a, FLOAT b)
  94. {
  95.   return IEEESPCmp (a, b);
  96. }
  97. #endif
  98.  
  99. #if defined(L__ledf2) || defined(ALL)
  100. int __ledf2 (double a, double b)
  101. {
  102.   return ieeedpcmp (a, b);
  103. }
  104. #endif
  105.  
  106. #if defined(L__lesf2) || defined(ALL)
  107. int __lesf2 (FLOAT a, FLOAT b)
  108. {
  109.   return IEEESPCmp (a, b);
  110. }
  111. #endif
  112.  
  113. #if defined(L__ltdf2) || defined(ALL)
  114. int __ltdf2 (double a, double b)
  115. {
  116.   return ieeedpcmp (a, b);
  117. }
  118. #endif
  119.  
  120. #if defined(L__ltsf2) || defined(ALL)
  121. int __ltsf2 (FLOAT a, FLOAT b)
  122. {
  123.   return IEEESPCmp (a, b);
  124. }
  125. #endif
  126.  
  127. #if defined(L__nedf2) || defined(ALL)
  128. int __nedf2 (double a, double b)
  129. {
  130.   return !!ieeedpcmp (a, b);
  131. }
  132. #endif
  133.  
  134. #if defined(L__nesf2) || defined(ALL)
  135. int __nesf2 (FLOAT a, FLOAT b)
  136. {
  137.   return !!IEEESPCmp (a, b);
  138. }
  139. #endif
  140.  
  141.  
  142.  
  143.  
  144. #if defined (mc68020) || defined (mc68030) || defined (mc68040) || defined (mc68060)
  145.  
  146. /* int / int */
  147. #if defined(L__divsi3) || defined(ALL)
  148. ENTRY(__divsi3)
  149. asm("
  150.     movel    sp@(4),d0
  151.     divsl    sp@(8),d0
  152.     rts
  153. ");
  154. #endif
  155.  
  156. /* int % int */
  157. #if defined(L__modsi3) || defined(ALL)
  158. ENTRY(__modsi3)
  159. asm("
  160.     movel    sp@(4),d1
  161.     divsll    sp@(8),d0:d1
  162.     rts
  163. ");
  164. #endif
  165.  
  166. /* int * int */
  167. #if defined(L__mulsi3) || defined(ALL)
  168. ENTRY(__mulsi3)
  169. asm("
  170.     movel    sp@(4),d0
  171.     mulsl    sp@(8),d0
  172.     rts
  173. ");
  174. #endif
  175.  
  176. /* unsigned / unsigned */
  177. #if defined(L__udivsi3) || defined(ALL)
  178. ENTRY(__udivsi3)
  179. asm("
  180.     movel    sp@(4),d0
  181.     divul    sp@(8),d0
  182.     rts
  183. ");
  184. #endif
  185.  
  186. /* unsigned % unsigned */
  187. #if defined(L__umodsi3) || defined(ALL)
  188. ENTRY(__umodsi3)
  189. asm("
  190.     movel    sp@(4),d1
  191.     divull    sp@(8),d0:d1
  192.     rts
  193. ");
  194. #endif
  195.  
  196. /* unsigned * unsigned */
  197. #if defined(L__umulsi3) || defined(ALL)
  198. ENTRY(__umulsi3)
  199. asm("
  200.     movel    sp@(4),d0
  201.     mulul    sp@(8),d0
  202.     rts
  203. ");
  204. #endif
  205.  
  206.  
  207. #else
  208.  
  209.  
  210. #if defined(L__divsi3) || defined(ALL)
  211. SItype __divsi3 (SItype a, SItype b)
  212. {
  213.   unsigned SItype q, r;
  214.   int neg = (a < 0) != (b < 0);
  215.  
  216.   if (a < 0) a = -a;
  217.   if (b < 0) b = -b;
  218.  
  219.   divmodu (q, r, a, b);
  220.  
  221.   return neg ? -q : q;
  222. }
  223. #endif
  224.  
  225. #if defined(L__modsi3) || defined(ALL)
  226. SItype __modsi3 (SItype a, SItype b)
  227. {
  228.   unsigned SItype q, r;
  229.   int neg = (a < 0);
  230.  
  231.   if (a < 0) a = -a;
  232.   if (b < 0) b = -b;
  233.  
  234.   divmodu (q, r, a, b);
  235.  
  236.   return neg ? -r : r;
  237. }
  238. #endif
  239.  
  240. #if defined(L__mulsi3) || defined(ALL)
  241. SItype __mulsi3 (SItype a, SItype b)
  242. {
  243.   int neg = (a < 0) != (b < 0);
  244.   SItype res;
  245.  
  246.   if (a < 0) a = -a;
  247.   if (b < 0) b = -b;
  248.   
  249.   res = mulu (a,b);
  250.   return neg ? -res : res;
  251. }
  252. #endif
  253.  
  254. #if defined(L__udivsi3) || defined(ALL)
  255. unsigned SItype __udivsi3 (unsigned SItype a, unsigned SItype b)
  256. {
  257.   unsigned SItype q, r;
  258.   divmodu (q, r, a, b);
  259.   return q;
  260. }
  261. #endif
  262.  
  263. #if defined(L__umodsi3) || defined(ALL)
  264. unsigned SItype __umodsi3 (unsigned SItype a, unsigned SItype b)
  265. {
  266.   unsigned SItype q, r;
  267.   divmodu (q, r, a, b);
  268.   return r;
  269. }
  270. #endif
  271.  
  272. #endif
  273.  
  274. /* -double */
  275. #if defined(L__negdf2) || defined(ALL)
  276. ENTRY(__negdf2)
  277. asm("
  278.     movel    sp@(4),d0
  279.     movel    sp@(8),d1
  280.     bchg    #31,d0
  281.     rts
  282. ");
  283. #endif
  284.  
  285. /* -single */
  286. #if defined(L__negsf2) || defined(ALL)
  287. ENTRY(__negsf2)
  288. asm("
  289.     movel    sp@(4),d0
  290.     bchg    #31,d0
  291.     rts
  292. ");
  293. #endif
  294.  
  295.  
  296.  
  297. #ifdef __HAVE_68881__
  298.  
  299. /* double + double */
  300. #if defined(L__adddf3) || defined(ALL)
  301. ENTRY(__adddf3)
  302. asm("
  303.     fmoved    sp@(4),fp0
  304.     faddd    sp@(12),fp0
  305.     fmoved    fp0,sp@-
  306.     movel    sp@+,d0
  307.     movel    sp@+,d1
  308.     rts
  309. ");
  310. #endif
  311.  
  312. /* single + single */
  313. #if defined(L__addsf3) || defined(ALL)
  314. ENTRY(__addsf3)
  315. asm("
  316.     fmoves    sp@(4),fp0
  317.     fadds    sp@(8),fp0
  318.     fmoves    fp0,d0
  319.     rts
  320. ");
  321. #endif
  322.  
  323. /* double > double: 1 */
  324. /* double < double: -1 */
  325. /* double == double: 0 */
  326. #if defined(L__cmpdf2) || defined(ALL)
  327. ENTRY(__cmpdf2)
  328. asm("
  329.     fmoved    sp@(4),fp0
  330.     fcmpd    sp@(12),fp0
  331.     fbgt    Lagtb1
  332.     fslt    d0
  333.     extbl    d0
  334.     rts
  335. Lagtb1:
  336.     moveq    #1,d0
  337.     rts
  338. ");
  339. #endif
  340.  
  341. /* single > single: 1 */
  342. /* single < single: -1 */
  343. /* single == single: 0 */
  344. #if defined(L__cmpsf2) || defined(ALL)
  345. ENTRY(__cmpsf2)
  346. asm("
  347.     fmoves    sp@(4),fp0
  348.     fcmps    sp@(8),fp0
  349.     fbgt    Lagtb2
  350.     fslt    d0
  351.     extbl    d0
  352.     rts
  353. Lagtb2:
  354.     moveq    #1,d0
  355.     rts
  356. ");
  357. #endif
  358.  
  359. /* double / double */
  360. #if defined(L__divdf3) || defined(ALL)
  361. ENTRY(__divdf3)
  362. asm("
  363.     fmoved    sp@(4),fp0
  364.     fdivd    sp@(12),fp0
  365.     fmoved    fp0,sp@-
  366.     movel    sp@+,d0
  367.     movel    sp@+,d1
  368.     rts
  369. ");
  370. #endif
  371.  
  372. /* single / single */
  373. #if defined(L__divsf3) || defined(ALL)
  374. ENTRY(__divsf3)
  375. asm("
  376.     fmoves    sp@(4),fp0
  377.     fdivs    sp@(8),fp0
  378.     fmoves    fp0,d0
  379.     rts
  380. ");
  381. #endif
  382.  
  383. /* (double) float */
  384. #if defined(L__extendsfdf2) || defined(ALL)
  385. ENTRY(__extendsfdf2)
  386. asm("
  387.     fmoves    sp@(4),fp0
  388.     fmoved    fp0,sp@-
  389.     movel    sp@+,d0
  390.     movel    sp@+,d1
  391.     rts
  392. ");
  393. #endif
  394.  
  395. #if defined(Lfabs) || defined(ALL)
  396. ENTRY(fabs)
  397. asm("
  398.     fmoved    sp@(4),fp0
  399.     fjnlt    L1
  400.     fnegx    fp0
  401. L1:
  402.     fmoved    fp0,sp@-
  403.     movel    sp@+,d0
  404.     movel    sp@+,d1
  405.     rts
  406. ");
  407. #endif
  408.  
  409. /* (int) double */
  410. #if defined(L__fixdfsi) || defined(ALL)
  411. ENTRY(__fixdfsi)
  412. asm("
  413.     fintrzd    sp@(4),fp0
  414.     fmovel    fp0,d0
  415.     rts
  416. ");
  417. #endif
  418.  
  419. /* (double) int */
  420. #if defined(L__floatsidf) || defined(ALL)
  421. ENTRY(__floatsidf)
  422. asm("
  423.     fmovel    sp@(4),fp0
  424.     fmoved    fp0,sp@-
  425.     movel    sp@+,d0
  426.     movel    sp@+,d1
  427.     rts
  428. ");
  429. #endif
  430.  
  431. /*
  432.  * double frexp(val, eptr)
  433.  * returns: x s.t. val = x * (2 ** n), with n stored in *eptr
  434.  */
  435. #if defined(Lfrexp) || defined(ALL)
  436. ENTRY(frexp)
  437. asm("
  438.     fmoved        sp@(4),fp1
  439.     fgetmanx    fp1,fp0
  440.     fgetexpx    fp1
  441.     fmovel        fp1,d0
  442.     addql        #1,d0
  443.     movel        sp@(12),a0
  444.     movel        d0,a0@
  445.     fdivl        #2,fp0
  446.     fmoved        fp0,sp@-
  447.     movel        sp@+,d0
  448.     movel        sp@+,d1
  449.     rts
  450. ");
  451. #endif
  452.  
  453. /*
  454.  * double ldexp(val, exp)
  455.  * returns: val * (2**exp), for integer exp
  456.  */
  457. #if defined(Lldexp) || defined(ALL)
  458. ENTRY(ldexp)
  459. asm("
  460.     fmoved        sp@(4),fp0
  461.     fbeq        Ldone
  462.     ftwotoxl    sp@(12),fp1
  463.     fmulx        fp1,fp0
  464. Ldone:
  465.     fmoved        fp0,sp@-
  466.     movel        sp@+,d0
  467.     movel        sp@+,d1
  468.     rts
  469. ");
  470. #endif
  471.  
  472. /*
  473.  * double modf(val, iptr)
  474.  * returns: xxx and n (in *iptr) where val == n.xxx
  475.  */
  476. #if defined(Lmodf) || defined(ALL)
  477. ENTRY(modf)
  478. asm("
  479.     fmoved    sp@(4),fp0
  480.     movel    sp@(12),a0
  481.     fintrzx    fp0,fp1
  482.     fmoved    fp1,a0@
  483.     fsubx    fp1,fp0
  484.     fmoved    fp0,sp@-
  485.     movel    sp@+,d0
  486.     movel    sp@+,d1
  487.     rts
  488. ");
  489. #endif
  490.  
  491. /* double * double */
  492. #if defined(L__muldf3) || defined(ALL)
  493. ENTRY(__muldf3)
  494. asm("
  495.     fmoved    sp@(4),fp0
  496.     fmuld    sp@(12),fp0
  497.     fmoved    fp0,sp@-
  498.     movel    sp@+,d0
  499.     movel    sp@+,d1
  500.     rts
  501. ");
  502. #endif
  503.  
  504. /* single * single */
  505. #if defined(L__mulsf3) || defined(ALL)
  506. ENTRY(__mulsf3)
  507. asm("
  508.     fmoves    sp@(4),fp0
  509.     fmuls    sp@(8),fp0
  510.     fmoves    fp0,d0
  511.     rts
  512. ");
  513. #endif
  514.  
  515. /* double - double */
  516. #if defined(L__subdf3) || defined(ALL)
  517. ENTRY(__subdf3)
  518. asm("
  519.     fmoved    sp@(4),fp0
  520.     fsubd    sp@(12),fp0
  521.     fmoved    fp0,sp@-
  522.     movel    sp@+,d0
  523.     movel    sp@+,d1
  524.     rts
  525. ");
  526. #endif
  527.  
  528. /* single - single */
  529. #if defined(L__subsf3) || defined(ALL)
  530. ENTRY(__subsf3)
  531. asm("
  532.     fmoves    sp@(4),fp0
  533.     fsubs    sp@(8),fp0
  534.     fmoves    fp0,d0
  535.     rts
  536. ");
  537. #endif
  538.  
  539. /* (float) double */
  540. #if defined(L__truncdfsf2) || defined(ALL)
  541. ENTRY(__truncdfsf2)
  542. asm("
  543.     fmoved    sp@(4),fp0
  544.     fmoves    fp0,d0
  545.     rts
  546. ");
  547. #endif
  548.  
  549. #else /* __HAVE_68881__ */
  550.  
  551. #if defined(L__adddf3) || defined(ALL)
  552. double __adddf3 (double a, double b)
  553. {
  554.   return IEEEDPAdd (a, b);
  555. }
  556. #endif
  557.  
  558. #if defined(L__addsf3) || defined(ALL)
  559. SFVALUE __addsf3 (FLOAT a, FLOAT b)
  560. {
  561.   return IEEESPAdd (a, b);
  562. }
  563. #endif
  564.  
  565. #if defined(L__cmpdf2) || defined(ALL)
  566. int __cmpdf2 (double a, double b)
  567. {
  568.   return ieeedpcmp (a, b);
  569. }
  570. #endif
  571.  
  572. #if defined(L__cmpsf2) || defined(ALL)
  573. int __cmpsf2 (FLOAT a, FLOAT b)
  574. {
  575.   return IEEESPCmp (a, b);
  576. }
  577. #endif
  578.  
  579. #if defined(L__divdf3) || defined(ALL)
  580. double __divdf3 (double a, double b)
  581. {
  582.   return IEEEDPDiv (a, b);
  583. }
  584. #endif
  585.  
  586. #if defined(L__divsf3) || defined(ALL)
  587. SFVALUE __divsf3 (FLOAT a, FLOAT b)
  588. {
  589.   return IEEESPDiv (a, b);
  590. }
  591. #endif
  592.  
  593. #if defined(L__extendsfdf2) || defined(ALL)
  594. double __extendsfdf2 (FLOAT a)
  595. {
  596.   return IEEEDPFieee(a);
  597. }
  598. #endif
  599.  
  600. #if defined(Lfabs) || defined(ALL)
  601. double fabs (double d)
  602. {
  603.   return d < 0.0 ? -d : d;
  604. }
  605. #endif
  606.  
  607. #if defined(L__fixdfsi) || defined(ALL)
  608. SItype __fixdfsi (double a)
  609. {
  610.   return IEEEDPFix (a);
  611. }
  612. #endif
  613.  
  614. #if defined(L__floatsidf) || defined(ALL)
  615. double __floatsidf (SItype a)
  616. {
  617.   return IEEEDPFlt (a);
  618. }
  619. #endif
  620.  
  621. /*
  622.  *    the call
  623.  *        x = frexp(arg,&exp);
  624.  *    must return a double fp quantity x which is <1.0
  625.  *    and the corresponding binary exponent "exp".
  626.  *    such that
  627.  *        arg = x*2^exp
  628.  *    if the argument is 0.0, return 0.0 mantissa and 0 exponent.
  629.  */
  630.  
  631. #if defined(Lfrexp) || defined(ALL)
  632. double frexp (double x, int *i)
  633. {
  634.   int neg = 0;
  635.   int j = 0;
  636.  
  637.   if (x < 0)
  638.     {
  639.       x = -x;
  640.       neg = 1;
  641.     }
  642.  
  643.   if (x >= 1.0)
  644.     while (x >= 1.0)
  645.       {
  646.     j = j + 1;
  647.     x = x / 2;
  648.       }
  649.   else if (x < 0.5 && x != 0.0)
  650.     while (x < 0.5)
  651.       {
  652.     j = j - 1;
  653.     x = 2 * x;
  654.       }
  655.  
  656.   *i = j;
  657.   if (neg)
  658.     x = -x;
  659.   return x;
  660. }
  661. #endif
  662.  
  663. #if defined(Lldexp) || defined(ALL)
  664. /*
  665.  * ldexp returns the quanity "value" * 2 ^ "exp"
  666.  *
  667.  * For the mc68000 using IEEE format the double precision word format is:
  668.  *
  669.  * WORD N   =>    SEEEEEEEEEEEMMMM
  670.  * WORD N+1 =>    MMMMMMMMMMMMMMMM
  671.  * WORD N+2 =>    MMMMMMMMMMMMMMMM
  672.  * WORD N+3 =>    MMMMMMMMMMMMMMMM
  673.  *
  674.  * Where:          S  =>   Sign bit
  675.  *                 E  =>   Exponent
  676.  *                 X  =>   Ignored (set to 0)
  677.  *                 M  =>   Mantissa bit
  678.  *
  679.  * NOTE:  Beware of 0.0; on some machines which use excess 128 notation for the
  680.  * exponent, if the mantissa is zero the exponent is also.
  681.  *
  682.  */
  683.  
  684. #define MANT_MASK 0x800FFFFF    /* Mantissa extraction mask     */
  685. #define ZPOS_MASK 0x3FF00000    /* Positive # mask for exp = 0  */
  686. #define ZNEG_MASK 0x3FF00000    /* Negative # mask for exp = 0  */
  687.  
  688. #define EXP_MASK 0x7FF00000    /* Mask for exponent            */
  689. #define EXP_SHIFTS 20        /* Shifts to get into LSB's     */
  690. #define EXP_BIAS 1023        /* Exponent bias                */
  691.  
  692. union dtol
  693. {
  694.   double dval;
  695.   int ival[2];
  696. };
  697.  
  698. double ldexp (double value, int exp)
  699. {
  700.   union dtol number;
  701.   int *iptr, cexp;
  702.  
  703.   if (value == 0.0)
  704.     return (0.0);
  705.   number.dval = value;
  706.   iptr = &number.ival[0];
  707.   cexp = (((*iptr) & EXP_MASK) >> EXP_SHIFTS) - EXP_BIAS;
  708.   *iptr &= ~EXP_MASK;
  709.   exp += EXP_BIAS;
  710.   *iptr |= ((exp + cexp) << EXP_SHIFTS) & EXP_MASK;
  711.   return (number.dval);
  712. }
  713. #endif
  714.  
  715. /*
  716.  * modf(value, iptr): return fractional part of value, and stores the
  717.  * integral part into iptr (a pointer to double).
  718.  */
  719.  
  720. #if defined(Lmodf) || defined(ALL)
  721. double modf (double value, double *iptr)
  722. {
  723.   /* if value negative */
  724.   if (IEEEDPTst (value) < 0)
  725.     {
  726.       /* in that case, the integer part is calculated by ceil() */
  727.       *iptr = IEEEDPCeil (value);
  728.       return IEEEDPSub (*iptr, value);
  729.     }
  730.   else
  731.     {
  732.       /* if positive, we go for the floor() */
  733.       *iptr = IEEEDPFloor (value);
  734.       return IEEEDPSub (value, *iptr);
  735.     }
  736. }
  737. #endif
  738.  
  739. #if defined(L__muldf3) || defined(ALL)
  740. double __muldf3 (double a, double b)
  741. {
  742.   return IEEEDPMul (a, b);
  743. }
  744. #endif
  745.  
  746. #if defined(L__mulsf3) || defined(ALL)
  747. SFVALUE __mulsf3 (FLOAT a, FLOAT b)
  748. {
  749.   return IEEESPMul (a, b);
  750. }
  751. #endif
  752.  
  753. #if defined(L__subdf3) || defined(ALL)
  754. double __subdf3 (double a, double b)
  755. {
  756.   return IEEEDPSub (a, b);
  757. }
  758. #endif
  759.  
  760. #if defined(L__subsf3) || defined(ALL)
  761. SFVALUE __subsf3 (FLOAT a, FLOAT b)
  762. {
  763.   return IEEESPSub (a, b);
  764. }
  765. #endif
  766.  
  767. #if defined(L__truncdfsf2) || defined(ALL)
  768. SFVALUE __truncdfsf2 (double a)
  769. {
  770.   return IEEEDPTieee(a);
  771. }
  772. #endif
  773.  
  774. #endif /* __HAVE_68881__ */
  775.